package juc.blockqueue.linkedblockdeque;

/**
 * @ClassName LinkedBlockingDequeExample
 * @PackageName juc.blockqueue.linkedblockdeque
 * @projectName myThread
 * @Description LinkedBlockingDequeExample
 * @Author games
 * @Date 2025/9/4 下午1:42
 * @Version 1.0
 */

/**
 * LinkedBlockingDeque 使用说明
 * LinkedBlockingDeque 是一个基于链表实现的可选有界双端阻塞队列，它实现了 BlockingDeque 接口，支持在队列的两端进行插入和移除操作。
 * 基本特性
 * 双端操作：支持在队列的头部和尾部进行插入和移除操作
 * 可选有界：
 * 可以指定容量（有界队列）
 * 不指定容量时默认为 Integer.MAX_VALUE（近似无界队列）
 * 阻塞特性：
 * 当队列满时，插入操作会阻塞
 * 当队列空时，移除操作会阻塞
 * 线程安全：内部使用锁机制保证多线程环境下的安全性
 * FIFO 和 FILO：支持先进先出和先进后出两种模式
 *
 * // 默认构造函数，创建容量为 Integer.MAX_VALUE 的双端队列
 * LinkedBlockingDeque<Integer> deque1 = new LinkedBlockingDeque<>();
 *
 * // 指定容量的构造函数
 * LinkedBlockingDeque<Integer> deque2 = new LinkedBlockingDeque<>(100);
 *
 * // 从集合初始化
 * LinkedBlockingDeque<Integer> deque3 = new LinkedBlockingDeque<>(Arrays.asList(1, 2, 3));
 *
 *
 * 主要方法
 * 头部操作
 * putFirst(E e)：在队列头部插入元素，队列满时阻塞
 * offerFirst(E e)：在队列头部插入元素，立即返回 true/false
 * takeFirst()：从队列头部移除并返回元素，队列空时阻塞
 * pollFirst()：从队列头部移除并返回元素，立即返回元素或 null
 * 尾部操作
 * putLast(E e)：在队列尾部插入元素，队列满时阻塞
 * offerLast(E e)：在队列尾部插入元素，立即返回 true/false
 * takeLast()：从队列尾部移除并返回元素，队列空时阻塞
 * pollLast()：从队列尾部移除并返回元素，立即返回元素或 null
 * 通用阻塞队列操作（兼容 BlockingQueue）
 * put(E e)：等同于 putLast(e)
 * take()：等同于 takeFirst()
 * offer(E e)：等同于 offerLast(e)
 * poll()：等同于 pollFirst()
 */

import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.BlockingDeque;

public class LinkedBlockingDequeExample {
    public static void main(String[] args) {
        BlockingDeque<Integer> deque = new LinkedBlockingDeque<>();
        // 方法引用方式
        /**
         * 这个方法的签名正好匹配 Runnable.run()
         *
         */
        Runnable task3 = System.out::println;
        // 生产者线程
        Thread producer = new Thread(() -> {
            try {
                deque.addFirst(1);
                System.out.println("Produced: " + 1);
                deque.addLast(2);
                System.out.println("Produced: " + 2);
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        // 消费者线程
        Thread consumer = new Thread(() -> {
            try {
                System.out.println("Consumed: " + deque.takeFirst());
                System.out.println("Consumed: " + deque.takeLast());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        producer.start();
        consumer.start();
    }
}
